package controller;

import java.io.Serializable;
import java.math.BigDecimal;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Iterator;
import java.util.List;

import model.KlsConductor;
import model.KlsDocumentoTransporte;
import model.KlsDocumentoTransportePedido;
import model.KlsDocumentoTransportePedidoId;
import model.KlsEstadoConductor;
import model.KlsEstadoDocumentoTransporte;
import model.KlsEstadoPedido;
import model.KlsEstadoVehiculo;
import model.KlsPedido;
import model.KlsRecorrido;
import model.KlsUnidadTransporte;
import model.KlsUsuario;
import model.KlsVehiculo;
import model.KlsZonaEntrega;

import org.hibernate.HibernateException;
import org.hibernate.Session;

import util.HibernateUtil;

final class KlsPedidoUnidadTransporte
  {
    public KlsPedido klsPedido;
    public KlsUnidadTransporte klsUnidadTransporte;
  
  }


public class KlsDocumentoDeTransporteManager extends HibernateUtil {


	private List<KlsPedido> pedidosPendientes ;
    private List<KlsPedidoUnidadTransporte> pedidosAsignados;
	private KlsPedidoUnidadTransporte klsPedidoUnidadTransporte;
	private Session session;
	private static int ESTADO_DOC_TRANSPORTE_NUEVO = 1;
	private static int ESTADO_DOC_TRANSPORTE_PROGRAMADO = 2;
	private static int ESTADO_DOC_TRANSPORTE_TERMINADO = 12;
	
	private static int ESTADO_DOC_TRANSPORTE_ANULADO = 11;
	
	private static int ESTADO_PEDIDO_ASIGNADO = 2;
	private static int ESTADO_PEDIDO_PENDIENTE = 1;
	private static int ESTADO_PEDIDO_ENTREGADO = 5;
	private static int ESTADO_VEHICULO_ASIGNADO = 4;
	private static int ESTADO_VEHICULO_LIBRE = 1;
	
	private static int ESTADO_UNIDAD_TRANS_ASIGNADO = 4;
	private static int ESTADO_UNIDAD_TRANS_LIBRE = 1;	

	private static int ESTADO_CONDUCTOR_ASIGNADO = 4;
	private static int ESTADO_CONDUCTOR_LIBRE = 1;		
	
	
	private KlsConductor klsConductor;
	private KlsVehiculo klsVehiculo;
	private KlsUsuario klsUsuario;
	private KlsZonaEntrega klsZonaEntrega;



	private KlsEstadoDocumentoTransporte klsEstadoDocumentoTransporte;
	private KlsEstadoPedido klsEstadoPedido;
	private KlsDocumentoTransporte klsDocumentoTransporte;
	
	private BigDecimal volumenDocTransporte;
	private BigDecimal pesoDocTransporte;
	private KlsDocumentoTransportePedido klsDocumentoTransportePedido;
	private KlsDocumentoTransportePedidoId klsDocumentoTransportePedidoId;
	


	
    public KlsDocumentoTransporte load(int idDocTransporte) {
        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        session.beginTransaction();
        klsDocumentoTransporte = (KlsDocumentoTransporte) session.get(KlsDocumentoTransporte.class, idDocTransporte); // load(Usuario.class, id);
        session.getTransaction().commit();
        return klsDocumentoTransporte;
    }
    
    
	public List<KlsDocumentoTransporte> list() {
        
        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        session.beginTransaction();
        List<KlsDocumentoTransporte> docs = null;
        try {
             
            docs = session.createQuery("from KlsDocumentoTransporte").list();
            session.getTransaction().commit();
        } 
        catch (HibernateException e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        
        }
        
        return docs;
    }


	public List<KlsDocumentoTransporte> listPorEstado() {
        
        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        session.beginTransaction();
        List<KlsDocumentoTransporte> docsPorEstado = null;
        try {
             
            docsPorEstado = session.createQuery("from KlsDocumentoTransporte where id_estado = 4").list();
             
        } 
        catch (HibernateException e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        
        }
        session.getTransaction().commit();
        return docsPorEstado;
    }

	
	

	public KlsDocumentoTransporte crearDocumentoTransporte(int piVehiculo, int piConductor, int idUsuario) {
		
		
		klsDocumentoTransporte = new KlsDocumentoTransporte();

	    	
	    //asignar valores al documento de transporte
	    
	    Calendar c = Calendar.getInstance();
		DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
		String fecha = df.format( c.getTime());
	    	
	    klsDocumentoTransporte.setKlsEstadoDocumentoTransporte(klsEstadoDocumentoTransporte);
	    klsDocumentoTransporte.setKlsZonaEntrega(klsZonaEntrega);
	    klsDocumentoTransporte.setKlsUsuarioByIdUsuarioCreador(klsUsuario);
	    klsDocumentoTransporte.setKlsUsuarioByIdUsuarioModificador(klsUsuario);
	    klsDocumentoTransporte.setKlsVehiculo(klsVehiculo);
	    klsDocumentoTransporte.setKlsConductor(klsConductor);
	    klsDocumentoTransporte.setIdDocumentoProgramacion(getDocDeProgramacion());
		klsDocumentoTransporte.setFechaCreacion(fecha);
		klsDocumentoTransporte.setFechaModificacion(fecha);
		klsDocumentoTransporte.setDisponiblePeso( pesoDocTransporte );
	    klsDocumentoTransporte.setDisponibleVolumen(volumenDocTransporte);
	
			
	    try {
	       session.save(klsDocumentoTransporte);
	        }
	    catch (HibernateException e) {
	            e.printStackTrace();
	            session.getTransaction().rollback();
	        }
	     return klsDocumentoTransporte;

		
	}


	private void cargarObjetosRelacionados(int piVehiculo, int piConductor,
			int idUsuario) {
		//Managers para cargar objetos
		 KlsEstadoDocumentoTransporteManager klsEstadoDocumentoTransporteManager = new KlsEstadoDocumentoTransporteManager();
		 KlsZonaManager klsZonaaManager = new KlsZonaManager();
		 KlsUsuarioManager klsUsuarioManager = new KlsUsuarioManager();
		 KlsVehiculoManager klsVehiculoManager = new KlsVehiculoManager();
		 KlsConductorManager klsConductorManager = new KlsConductorManager();
		 KlsEstadoPedidoManager klsEstadoPedidoManager = new KlsEstadoPedidoManager(); 
		 
		//Cargar objetos relacionados
	    klsEstadoDocumentoTransporte = klsEstadoDocumentoTransporteManager.load(ESTADO_DOC_TRANSPORTE_NUEVO); 
	    klsVehiculo = klsVehiculoManager.load(piVehiculo);
	    klsZonaEntrega = klsZonaaManager.load(klsVehiculo.getKlsZonaEntrega().getIdZonaEntrega());
	    klsUsuario = klsUsuarioManager.load(idUsuario);  
	    klsConductor = klsConductorManager.load(piConductor);
	    
	    
		
	      //le asigno el estado 2 = pendiente de entrega
			klsEstadoPedido = klsEstadoPedidoManager.load(ESTADO_PEDIDO_ASIGNADO);
	}
	
	
	private int getDocDeProgramacion() {
		// TODO Auto-generated method stub calcular documento de programacion en base a la fecha
		return 0;
	}

	public void eliminarPedidoDocTransporte (int idPedido, int idDocTransporte)
	{
		//me traigo objeto estado pedido pendiente pra asignar al pedido eliminado
		KlsEstadoPedidoManager klsEstadoPedidoManager = new KlsEstadoPedidoManager();	
		klsEstadoPedido = klsEstadoPedidoManager.load(ESTADO_PEDIDO_PENDIENTE);
		
		//inicio la transaccion
	    session = HibernateUtil.getSessionFactory().getCurrentSession();
	    session.beginTransaction();

	    //cargo el documento transporte pedido
		KlsDocumentoTransportePedidoManager klsDocumentoTransportePedidoManager = new KlsDocumentoTransportePedidoManager();
		klsDocumentoTransportePedido = klsDocumentoTransportePedidoManager.get(idDocTransporte, idPedido, session);
		KlsPedido klsPedido;
        klsPedido = klsDocumentoTransportePedido.getKlsPedido();
		try{		
		//cargar doc de transporte
	    klsDocumentoTransporte = (KlsDocumentoTransporte) session.get(KlsDocumentoTransporte.class, idDocTransporte); 

		//ACTUALIZO LOS CONTADORES DEL DOC DE TRANSPORTE
	    BigDecimal volumen = klsDocumentoTransporte.getDisponibleVolumen();
	    BigDecimal peso = klsDocumentoTransporte.getDisponiblePeso();
	    volumen = volumen.subtract(klsPedido.getVolumenTotal());
	    peso = peso.subtract(klsPedido.getPesoTotal());
	    klsDocumentoTransporte.setDisponibleVolumen(volumen);
		klsDocumentoTransporte.setDisponiblePeso(peso);		
		
		
		//actualiza el estado del pedido
	    //le asigno el estado 1 = pendiente de entrega
		klsPedido.setKlsEstadoPedido(klsEstadoPedido);
	

		klsDocumentoTransporte.getKlsDocumentoTransportePedidos().remove(klsDocumentoTransportePedido);
        session.save(klsDocumentoTransporte);
        session.save(klsPedido);
        session.delete(klsDocumentoTransportePedido);
        session.getTransaction().commit();
		}
        catch(Exception e)
        {
        	e.printStackTrace();
        	 session.getTransaction().rollback();
        	
        }
		
        
        
        
		
	}
	
	
	public boolean addPedidoDocTransporte (int idPedido, int idDocTransporte)
	{
		//me traigo objeto estado pedido pendiente pra asignar al pedido eliminado
		KlsEstadoPedidoManager klsEstadoPedidoManager = new KlsEstadoPedidoManager();	
		klsEstadoPedido = klsEstadoPedidoManager.load(ESTADO_PEDIDO_ASIGNADO);

		klsDocumentoTransportePedido = new KlsDocumentoTransportePedido();
		
		KlsPedidoManager klsPedidoManager = new KlsPedidoManager();
		
        session = HibernateUtil.getSessionFactory().getCurrentSession();
        session.beginTransaction();
        
        //me traigo el pedido a agregar al doc de transporte
        KlsPedido klsPedido = (KlsPedido) session.get(KlsPedido.class, idPedido); 
		
        
	
	    klsDocumentoTransporte = (KlsDocumentoTransporte) session.get(KlsDocumentoTransporte.class, idDocTransporte); 
		
		klsVehiculo = klsDocumentoTransporte.getKlsVehiculo();
		
		//validar si el pedido se puede agregar al doc de transporte. PESO y VOLUMEN
		KlsUnidadTransporte klsUnidadTRansporte = validarPedidoEnDocDeTransporte(klsPedido );
		
		// si es  NULL al unidad de transporte significa que el pedido no entra
		if(klsUnidadTRansporte == null)
		{
			session.getTransaction().rollback();
			return false;
		}
        try{
		
		//ACTUALIZO LOS CONTADORES DEL DOC DE TRANSPORTE
		klsDocumentoTransporte.setDisponibleVolumen(klsDocumentoTransporte.getDisponibleVolumen()
				.add(klsPedido.getVolumenTotal()));
		klsDocumentoTransporte.setDisponiblePeso(klsDocumentoTransporte.getDisponiblePeso()
				.add(klsPedido.getPesoTotal()));		
		
		
		//actualizo el estado del pedido
		klsPedido.setKlsEstadoPedido(klsEstadoPedido);
		
		
        //inserto doc de transporte pedido con el pedido a agregar
		 insertDocTransportePedido(klsDocumentoTransporte, klsPedido,
				 klsUnidadTRansporte);	
        
		session.save(klsPedido);
        session.save(klsDocumentoTransporte);
        session.save(klsDocumentoTransportePedido);
        session.getTransaction().commit();
        }
        catch(Exception e)
        {
        	e.printStackTrace();
        	 session.getTransaction().rollback();
        	
        }
        
        
        
		return true;
	}

	//esto metodo devulve una lista de objetos porque el resultado no esta mapeado a un objeto
	private List obtenerAsignacionDepedidos()
	{
		List asignacionPedidos;
		
		String query  = "  select dtp.id_unidad_transporte ," +
				"		   peso_max,peso_max -SUM(peso_total) peso_libre , " +
				"		   SUM(peso_total) peso_ocupado ," +
				"		   volumen_max, volumen_max -SUM(volumen_total)  " +
				"          volumen_libre, SUM(volumen_total) volumen_ocupado"+
				"	 from kls_documento_transporte_pedido dtp"+
				"	inner join kls_pedido p on"+ 
				"	p.id_pedido = dtp.id_pedido"+
				"	inner join kls_unidad_transporte ut"+
				"	on dtp.id_unidad_transporte = ut.id_unidad_transporte"+
				"	where dtp.id_documento_transporte = :doc_transporte "+
				"	group by  dtp.id_unidad_transporte,peso_max,volumen_max";
		
		
		asignacionPedidos = session.createSQLQuery(query).
				setParameter("doc_transporte", klsDocumentoTransporte.getIdDocumentoTransporte())
				.list();
		return asignacionPedidos;
		
	}
	
	
	
	private KlsUnidadTransporte validarPedidoEnDocDeTransporte(KlsPedido klsPedido){
		
		KlsUnidadTransporte unidadTransporte = null;
		
		KlsUnidadTransporteManager klsUnidadTransporteManager = new KlsUnidadTransporteManager();
		
		
		List pedidosAsigandos = obtenerAsignacionDepedidos();
		
		Iterator iteraAsignados = pedidosAsigandos.iterator();
		
		BigDecimal pesoLibre;
		String sPesoLibre;

		BigDecimal volmenLibre;
		String sVolLibre;
		
		int id_unidad_transporte;
		
		while(iteraAsignados.hasNext())
		{
			Object vectorAsignacion[] = (Object[]) iteraAsignados.next();
			
			// posicion 0 : id unidad transporte
			// posicion 1 : peso_max
			// posicion 2 : peso_libre
			// posicion 3 : peso_ocupado
			// posicion 4 : volumen_max
			// posicion 5 : volumen_libre
			// posicion 6 : volumen_ocupado
			
			sPesoLibre = vectorAsignacion[2].toString();
			pesoLibre = new BigDecimal(sPesoLibre);

			sVolLibre = vectorAsignacion[5].toString();
			volmenLibre = new BigDecimal(sVolLibre);			
			
			id_unidad_transporte = Integer.valueOf( vectorAsignacion[0].toString());

			if(klsPedido.getPesoTotal().compareTo(pesoLibre) == -1
					&& klsPedido.getVolumenTotal().compareTo(volmenLibre) == -1)
			{
				unidadTransporte = klsUnidadTransporteManager.loadConSesion(id_unidad_transporte,session);
				break;
			}
			
			
			
		}
		
		 
		 

		
		return unidadTransporte;
		
	}



	public void optimizacionAutomatica( int piEstado, int piCriterio, int piVehiculo,int piConductor, int idUsuario) {
		
		cargarObjetosRelacionados(piVehiculo, piConductor, idUsuario);
		BigDecimal pesoAux;
		BigDecimal volumenAux;
		
		
		pesoDocTransporte = new BigDecimal(0);
		volumenDocTransporte = new BigDecimal(0);
		
		
		//buscar pedidos ordenados por prioridad
		KlsPedidoManager klsPedidoManager = new KlsPedidoManager();
		List<KlsPedido> pedidos = klsPedidoManager.listPorEstadoYZona( klsVehiculo.getKlsZonaEntrega().getIdZonaEntrega(),  piEstado,  piCriterio);
		KlsPedido klsPedido;
		KlsUnidadTransporte klsUnidadTransporte;
		pedidosPendientes = new ArrayList<KlsPedido>();
		pedidosPendientes.addAll(pedidos);
		pedidosAsignados = new ArrayList<KlsPedidoUnidadTransporte>();
    
		
		
		//levanto la session para encapsular todas las acciones del metodo
		session = HibernateUtil.getSessionFactory().getCurrentSession();
        session.beginTransaction();
		/////////////////////////////////////////////////////////////////
		
		
		//recorrer pedidos
		Iterator<KlsPedido> iteratorPedidos = pedidos.iterator();
		
		//TODO: definir el orden en que tienen que venir las unidades de transporte
		
		Iterator<KlsUnidadTransporte> iteratorUnidadTransporte = klsVehiculo.getKlsUnidadTransportes().iterator() ;
		
		while(iteratorUnidadTransporte.hasNext())
		{
			 pesoAux =  new BigDecimal(0);
			 volumenAux = new BigDecimal(0);
			klsUnidadTransporte = (KlsUnidadTransporte) iteratorUnidadTransporte.next();
			while(iteratorPedidos.hasNext())
			{
				klsPedido = iteratorPedidos.next();
				
				// Validar pesos y volumen de pedidos, los que cumplen se insertan en una coleccion
				 
				 //-1, 0, or 1 as this BigDecimal is numerically less than, equal to, or greater than val.
				
				 pesoAux =  klsPedido.getPesoTotal().add(pesoAux);
				 volumenAux = volumenAux.add( klsPedido.getVolumenTotal());
				
				 if (  pesoAux.compareTo(  klsUnidadTransporte.getPesoMax()) == -1 && 
						 volumenAux.compareTo(BigDecimal.valueOf( klsUnidadTransporte.getVolumenMax().longValue()))== -1)
				 {
					 	klsPedidoUnidadTransporte = new KlsPedidoUnidadTransporte();
					 	klsPedidoUnidadTransporte.klsPedido = klsPedido;
					 	klsPedidoUnidadTransporte.klsUnidadTransporte = klsUnidadTransporte ;
					 	pedidosAsignados.add(klsPedidoUnidadTransporte);
					 	pedidosPendientes.remove(klsPedido);
					 	
					 	
					 	//actualizo totalizadores del documento de transporte
					 	volumenDocTransporte = volumenDocTransporte.add(klsPedido.getVolumenTotal());
					 	pesoDocTransporte = pesoDocTransporte.add(klsPedido.getPesoTotal());
					 	/////////////////////////////////////////////////////
				
				 }//if (  pesoAux.compareTo(
				 else
				 {
					 pesoAux =  pesoAux.subtract(klsPedido.getPesoTotal());
					 volumenAux = volumenAux.subtract( klsPedido.getVolumenTotal());
					 
				 }
			}//while(iteratorPedidos.hasNext())
			
		}//while(iteratorUnidadTransporte.hasNext()) 
		
		
		//validar si se asigno algun pedido en caso negativo que no grabe nada
		
		if (pedidosAsignados.size()== 0){
			session.getTransaction().rollback();
		}
		else
		{
		
		
		
      //Crear documento de transporte
       klsDocumentoTransporte = crearDocumentoTransporte(piVehiculo, piConductor, idUsuario);
      //ASignar pedidos al doc de transporte creado
      asignarPedidosADocDeTransporte( klsDocumentoTransporte);
      
      //Modificar estado de los pedidos seleccioandos
		  modificarEstadoPedidosAsignados();
		  
		  
		  //MODIFICO EL ESTADO DEL VEHICULO
		  modificarEstadoVehiculo(piVehiculo,ESTADO_VEHICULO_ASIGNADO);
		  
			 try
			 {
		  
			 //COMITEO LA SESSION///////////////////////////////////////////////
			 session.getTransaction().commit();
			 /////////////////////////////////////////////////////////////////
			 }
			 catch(Exception e)
			 {
					 e.printStackTrace();
					 session.getTransaction().rollback();
			 }
				 
		}
			 
		
		
	}


	private void modificarEstadoVehiculo(int piVehiculo, int estadoVehiculo) {
		
		KlsEstadoVehiculo klsEstadoVehiculo = (KlsEstadoVehiculo) session.get(KlsEstadoVehiculo.class, estadoVehiculo);
		
		KlsEstadoConductor klsEstadoConductor = (KlsEstadoConductor) session.get(KlsEstadoConductor.class,ESTADO_CONDUCTOR_ASIGNADO); 
		
		klsVehiculo = (KlsVehiculo) session.get(KlsVehiculo.class,piVehiculo);
		klsVehiculo.setKlsEstadoVehiculo(klsEstadoVehiculo);
		KlsConductor klsConductor = klsVehiculo.getKlsConductor();
		
		klsConductor.setKlsEstadoConductor(klsEstadoConductor);
		try{
		session.save(klsVehiculo);
		session.save(klsConductor);
		}
		catch (Exception e) {
			// TODO: handle exception
			 e.printStackTrace();
			 session.getTransaction().rollback();
			}
	}


	private void modificarEstadoPedidosAsignados() {
		KlsPedido klsPedido;
		KlsPedidoUnidadTransporte klsPedidoUnidadTransporte;

		Iterator<KlsPedidoUnidadTransporte> iteraPedidosAsignados = pedidosAsignados.iterator();
		
		while(iteraPedidosAsignados.hasNext())
		{
			klsPedidoUnidadTransporte = iteraPedidosAsignados.next();
			
			klsPedido = klsPedidoUnidadTransporte.klsPedido;
			
			klsPedido.setKlsEstadoPedido(klsEstadoPedido);
			//klsPedidoManager.update(klsPedido);
			
			try {
				session.update(klsPedido);
			} catch (Exception e) {
				 e.printStackTrace();
				 session.getTransaction().rollback();
				 break;
				
			}
			
		}
	}
	
   
   
	private void asignarPedidosADocDeTransporte(KlsDocumentoTransporte klsDocumentoTransporte) {
		Iterator<KlsPedidoUnidadTransporte> iteraPedidosAsignados = pedidosAsignados.iterator();
		while(iteraPedidosAsignados.hasNext())
		{
			
			klsPedidoUnidadTransporte = iteraPedidosAsignados.next();

			
			
			 KlsPedido klsPedido = klsPedidoUnidadTransporte.klsPedido;
			 
			 KlsUnidadTransporte klsUnidadTransporte = klsPedidoUnidadTransporte.klsUnidadTransporte;
			
			 insertDocTransportePedido(klsDocumentoTransporte, klsPedido, klsUnidadTransporte);			
			

		}
		try{
        session.save(klsDocumentoTransporte);
        }
        catch (HibernateException e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }

	}



	private void insertDocTransportePedido(
			KlsDocumentoTransporte klsDocumentoTransporte, KlsPedido klsPedido,
			KlsUnidadTransporte klsUnidadTransporte) {
		klsDocumentoTransportePedidoId = new KlsDocumentoTransportePedidoId();
		klsDocumentoTransportePedidoId.setIdDocumentoTransporte(klsDocumentoTransporte.getIdDocumentoTransporte());
		klsDocumentoTransportePedidoId.setIdPedido(klsPedido.getIdPedido());
     
		
		klsDocumentoTransportePedido = new KlsDocumentoTransportePedido();
		klsDocumentoTransportePedido.setKlsDocumentoTransporte(klsDocumentoTransporte);
		klsDocumentoTransportePedido.setKlsPedido(klsPedido);
		klsDocumentoTransportePedido.setKlsUnidadTransporte(klsUnidadTransporte );
		
		klsDocumentoTransportePedido.setKlsUnidadTransporte(klsUnidadTransporte);
		
		klsDocumentoTransportePedido.setEntregado(false);
		
		klsDocumentoTransportePedido.setId(klsDocumentoTransportePedidoId);
		
		klsDocumentoTransporte.getKlsDocumentoTransportePedidos().add(klsDocumentoTransportePedido);
		
		try{
		    session.save(klsDocumentoTransportePedido);
		    }
		    catch (HibernateException e) {
		        e.printStackTrace();
		        session.getTransaction().rollback();
		    }
	} 
	
	
	
	////////////////////////////////////////////////////////
	// CONFIRMAR ENMTREGAS
	////////////////////////////////////////////////////////
	
	public void confirmarEntregas(int  idDocumentoTransporte){
		
		Session session = HibernateUtil.getSessionFactory().getCurrentSession();
		session.beginTransaction();

		try {
		//actualizo el estado del doc de transporte
		klsDocumentoTransporte = (KlsDocumentoTransporte) session.get(KlsDocumentoTransporte.class, idDocumentoTransporte); 
		klsEstadoDocumentoTransporte = (KlsEstadoDocumentoTransporte) session.get(KlsEstadoDocumentoTransporte.class, ESTADO_DOC_TRANSPORTE_TERMINADO);
		klsDocumentoTransporte.setKlsEstadoDocumentoTransporte(klsEstadoDocumentoTransporte);
		session.update(klsDocumentoTransporte);
		///////////////////////////////////////////////////////////////////////////////////////
		
		
		//actualizo el estado del vehiculo	 y del conductor		
		//modificarEstadoVehiculo( klsDocumentoTransporte.getKlsVehiculo().getIdVehiculo(),  ESTADO_VEHICULO_LIBRE);
		
		KlsEstadoVehiculo klsEstadoVehiculo = (KlsEstadoVehiculo) session.get(KlsEstadoVehiculo.class, ESTADO_VEHICULO_LIBRE);
		KlsEstadoConductor klsEstadoConductor = (KlsEstadoConductor) session.get(KlsEstadoConductor.class,ESTADO_CONDUCTOR_LIBRE); 
		
		klsVehiculo = (KlsVehiculo) session.get(KlsVehiculo.class,klsDocumentoTransporte.getKlsVehiculo().getIdVehiculo());
		klsVehiculo.setKlsEstadoVehiculo(klsEstadoVehiculo);
		KlsConductor klsConductor = klsVehiculo.getKlsConductor();
		klsConductor.setKlsEstadoConductor(klsEstadoConductor);
		session.save(klsVehiculo);
		session.save(klsConductor);
		
		///////////////////////////////////////////////////////////////////////////////////////
		
		//actualizo el estado de los pedidos
		///////////////////////////////////////////////////////////////////////////////////////
		klsEstadoPedido = (KlsEstadoPedido) session.get(KlsEstadoPedido.class, ESTADO_PEDIDO_ENTREGADO);
		Iterator<KlsDocumentoTransportePedido> iteraDocTransportePedidos = klsDocumentoTransporte.getKlsDocumentoTransportePedidos().iterator();	
		KlsPedido klsPedido;
		
		while(iteraDocTransportePedidos.hasNext())
		{
			
			klsDocumentoTransportePedido = iteraDocTransportePedidos.next();
			
			klsDocumentoTransportePedido.setEntregado(true);
			
			klsPedido = klsDocumentoTransportePedido.getKlsPedido();
			
			klsPedido.setKlsEstadoPedido(klsEstadoPedido);
			
			session.save(klsPedido);
			
			session.save(klsDocumentoTransportePedido);
			
		}
		///////////////////////////////////////////////////////////////////////////////////////
		
		
		
		
		session.getTransaction().commit();


		
		
		} catch (Exception e) {
			 e.printStackTrace();
			 session.getTransaction().rollback();
					
		}
		
		
		
	}
	

	
	
	
	////////////////////////////////////////////////////////
	// ANULAR DOC TRANSPORTE 
	////////////////////////////////////////////////////////
	
	public void anularDocTransporte(int  idDocumentoTransporte){
		
		Session session = HibernateUtil.getSessionFactory().getCurrentSession();
		session.beginTransaction();

		try {
		//anulo el estado del doc de transporte
		klsDocumentoTransporte = (KlsDocumentoTransporte) session.get(KlsDocumentoTransporte.class, idDocumentoTransporte); 
		klsEstadoDocumentoTransporte = (KlsEstadoDocumentoTransporte) session.get(KlsEstadoDocumentoTransporte.class, ESTADO_DOC_TRANSPORTE_ANULADO);
		klsDocumentoTransporte.setKlsEstadoDocumentoTransporte(klsEstadoDocumentoTransporte);
		session.save(klsDocumentoTransporte);

		
		///////////////////////////////////////////////////////////////////////////////////////
		
		
		//actualizo el estado del vehiculo y del conductor		
		//modificarEstadoVehiculo( klsDocumentoTransporte.getKlsVehiculo().getIdVehiculo(),  ESTADO_VEHICULO_LIBRE);
		
		KlsEstadoVehiculo klsEstadoVehiculo = (KlsEstadoVehiculo) session.get(KlsEstadoVehiculo.class, ESTADO_VEHICULO_LIBRE);
		KlsEstadoConductor klsEstadoConductor = (KlsEstadoConductor) session.get(KlsEstadoConductor.class,ESTADO_CONDUCTOR_LIBRE); 
		
		klsVehiculo = (KlsVehiculo) session.get(KlsVehiculo.class,klsDocumentoTransporte.getKlsVehiculo().getIdVehiculo());
		klsVehiculo.setKlsEstadoVehiculo(klsEstadoVehiculo);
		KlsConductor klsConductor = klsVehiculo.getKlsConductor();
		klsConductor.setKlsEstadoConductor(klsEstadoConductor);
		session.save(klsVehiculo);
		session.save(klsConductor);
		
		///////////////////////////////////////////////////////////////////////////////////////
		
		//actualizo el estado de los pedidos y elimino la relacion entre el doc de transporte y el pedido
		///////////////////////////////////////////////////////////////////////////////////////
		klsEstadoPedido = (KlsEstadoPedido) session.get(KlsEstadoPedido.class, ESTADO_PEDIDO_PENDIENTE);
		Iterator<KlsDocumentoTransportePedido> iteraDocTransportePedidos = klsDocumentoTransporte.getKlsDocumentoTransportePedidos().iterator();	
		KlsPedido klsPedido;
		
		while(iteraDocTransportePedidos.hasNext())
		{
			
			klsDocumentoTransportePedido = iteraDocTransportePedidos.next();
			
			klsDocumentoTransportePedido.setEntregado(true);
			
			klsPedido = klsDocumentoTransportePedido.getKlsPedido();
			
			klsPedido.setKlsEstadoPedido(klsEstadoPedido);
			
			session.save(klsPedido);
			
			session.save(klsDocumentoTransportePedido);
			
		}
		///////////////////////////////////////////////////////////////////////////////////////
		
		
		
		
		session.getTransaction().commit();


		
		
		} catch (Exception e) {
			 e.printStackTrace();
			 session.getTransaction().rollback();
					
		}
		
		
		
	}
	
	
	public List<KlsPedido> getPedidosPendientes() {
		return pedidosPendientes;
	}


	public void setPedidosPendientes(List<KlsPedido> pedidosPendientes) {
		this.pedidosPendientes = pedidosPendientes;
	}


	public List<KlsPedido> getPedidosAsignados() {
		
		
		List<KlsPedido> pedidosAsignadosList = new ArrayList<KlsPedido>();
   		Iterator<KlsPedidoUnidadTransporte> iteraPedidosAsignados = pedidosAsignados.iterator();
		while(iteraPedidosAsignados.hasNext())
		{
			
			klsPedidoUnidadTransporte = iteraPedidosAsignados.next();
			pedidosAsignadosList.add(klsPedidoUnidadTransporte.klsPedido);

		}
		
		return pedidosAsignadosList;
	}


	public void setPedidosAsignados(List<KlsPedidoUnidadTransporte> pedidosAsignados) {
		this.pedidosAsignados = pedidosAsignados;
	}


	public KlsDocumentoTransporte getKlsDocumentoTransporte() {
		return klsDocumentoTransporte;
	}


	public void setKlsDocumentoTransporte(
			KlsDocumentoTransporte klsDocumentoTransporte) {
		this.klsDocumentoTransporte = klsDocumentoTransporte;
	}


	public BigDecimal getVolumenDocTransporte() {
		return volumenDocTransporte;
	}


	public void setVolumenDocTransporte(BigDecimal volumenDocTransporte) {
		this.volumenDocTransporte = volumenDocTransporte;
	}


	public BigDecimal getPesoDocTransporte() {
		return pesoDocTransporte;
	}


	public void setPesoDocTransporte(BigDecimal pesoDocTransporte) {
		this.pesoDocTransporte = pesoDocTransporte;
	}
	
	
	public KlsZonaEntrega getKlsZonaEntrega() {
		return klsZonaEntrega;
	}


	public void setKlsZonaEntrega(KlsZonaEntrega klsZonaEntrega) {
		this.klsZonaEntrega = klsZonaEntrega;
	}


	public KlsPedidoUnidadTransporte getKlsPedidoUnidadTransporte() {
		return klsPedidoUnidadTransporte;
	}


	public void setKlsPedidoUnidadTransporte(
			KlsPedidoUnidadTransporte klsPedidoUnidadTransporte) {
		this.klsPedidoUnidadTransporte = klsPedidoUnidadTransporte;
	}


	public Session getSession() {
		return session;
	}


	public void setSession(Session session) {
		this.session = session;
	}


	public static int getESTADO_DOC_TRANSPORTE_NUEVO() {
		return ESTADO_DOC_TRANSPORTE_NUEVO;
	}


	public static void setESTADO_DOC_TRANSPORTE_NUEVO(
			int eSTADO_DOC_TRANSPORTE_NUEVO) {
		ESTADO_DOC_TRANSPORTE_NUEVO = eSTADO_DOC_TRANSPORTE_NUEVO;
	}


	public static int getESTADO_DOC_TRANSPORTE_PROGRAMADO() {
		return ESTADO_DOC_TRANSPORTE_PROGRAMADO;
	}


	public static void setESTADO_DOC_TRANSPORTE_PROGRAMADO(
			int eSTADO_DOC_TRANSPORTE_PROGRAMADO) {
		ESTADO_DOC_TRANSPORTE_PROGRAMADO = eSTADO_DOC_TRANSPORTE_PROGRAMADO;
	}


	public static int getESTADO_PEDIDO_ASIGNADO() {
		return ESTADO_PEDIDO_ASIGNADO;
	}


	public static void setESTADO_PEDIDO_ASIGNADO(int eSTADO_PEDIDO_ASIGNADO) {
		ESTADO_PEDIDO_ASIGNADO = eSTADO_PEDIDO_ASIGNADO;
	}


	public static int getESTADO_PEDIDO_PENDIENTE() {
		return ESTADO_PEDIDO_PENDIENTE;
	}


	public static void setESTADO_PEDIDO_PENDIENTE(int eSTADO_PEDIDO_PENDIENTE) {
		ESTADO_PEDIDO_PENDIENTE = eSTADO_PEDIDO_PENDIENTE;
	}


	public static int getESTADO_VEHICULO_ASIGNADO() {
		return ESTADO_VEHICULO_ASIGNADO;
	}


	public static void setESTADO_VEHICULO_ASIGNADO(int eSTADO_VEHICULO_ASIGNADO) {
		ESTADO_VEHICULO_ASIGNADO = eSTADO_VEHICULO_ASIGNADO;
	}


	public KlsConductor getKlsConductor() {
		return klsConductor;
	}


	public void setKlsConductor(KlsConductor klsConductor) {
		this.klsConductor = klsConductor;
	}


	public KlsVehiculo getKlsVehiculo() {
		return klsVehiculo;
	}


	public void setKlsVehiculo(KlsVehiculo klsVehiculo) {
		this.klsVehiculo = klsVehiculo;
	}


	public KlsUsuario getKlsUsuario() {
		return klsUsuario;
	}


	public void setKlsUsuario(KlsUsuario klsUsuario) {
		this.klsUsuario = klsUsuario;
	}


	public KlsEstadoDocumentoTransporte getKlsEstadoDocumentoTransporte() {
		return klsEstadoDocumentoTransporte;
	}


	public void setKlsEstadoDocumentoTransporte(
			KlsEstadoDocumentoTransporte klsEstadoDocumentoTransporte) {
		this.klsEstadoDocumentoTransporte = klsEstadoDocumentoTransporte;
	}


	public KlsEstadoPedido getKlsEstadoPedido() {
		return klsEstadoPedido;
	}


	public void setKlsEstadoPedido(KlsEstadoPedido klsEstadoPedido) {
		this.klsEstadoPedido = klsEstadoPedido;
	}


	public KlsDocumentoTransportePedido getKlsDocumentoTransportePedido() {
		return klsDocumentoTransportePedido;
	}


	public void setKlsDocumentoTransportePedido(
			KlsDocumentoTransportePedido klsDocumentoTransportePedido) {
		this.klsDocumentoTransportePedido = klsDocumentoTransportePedido;
	}


	public KlsDocumentoTransportePedidoId getKlsDocumentoTransportePedidoId() {
		return klsDocumentoTransportePedidoId;
	}


	public void setKlsDocumentoTransportePedidoId(
			KlsDocumentoTransportePedidoId klsDocumentoTransportePedidoId) {
		this.klsDocumentoTransportePedidoId = klsDocumentoTransportePedidoId;
	}
   

	
	

}
